// 创建元素并初始化属性
/**
 * @author 古宽宏
 * @param type 元素类型 默认值div
 * @param {*} props props对象字段
 * @see target 将生成的dom节点插入到目标dom节点后面
 * @see className css样式名 字符串
 * @see attribute 设置元素的属性
 * @see nodeProps 设置dom属性
 * @see listeners 设置dom的事件
 * @see style 元素行内样式 可以是字符串或者对象 案例 style="width:100px;text-align: center;"  style={width:'100px',textAlign: 'center'}
 * @see innerText 元素内部文本
 * @see child 插入到此元素的dom节点
 * @see childs 插入到此元素的dom数组
 */
function gkhCreate(type, props) {
  if (!type) {
    type = 'div';
  }
  if (!props) {
    props = {};
  }
  const { className, style, attribute, child, target, innerText, childs, nodeProps, listeners } = props;
  const node = document.createElement(type);
  if (style instanceof Object) {
    for (var key in style) {
      node.style[key] = style[key];
    }
  } else if (style) {
    node.style = style;
  }
  if (attribute instanceof Object) {
    for (var key in attribute) {
      node.setAttribute(key, attribute[key]);
    }
  }
  if (nodeProps instanceof Object) {
    for (var key in nodeProps) {
      node[nodeProps] = nodeProps[key];
    }
  }
  if (listeners instanceof Object) {
    for (var key in listeners) {
      node.addEventListener(key, listeners[key], false);
    }
  }
  if (className) {
    node.setAttribute('class', className);
  }
  if (target instanceof Node) {
    target.appendChild(node);
  }
  if (innerText) {
    node.innerText = innerText;
  }
  if (child instanceof Node) {
    node.appendChild(child);
  }
  if (childs instanceof Array) {
    for (let i = 0; i < childs.length; i += 1) {
      node.appendChild(childs[i]);
    }
  }
  return node;
}

/**
 * @author 古宽宏
 * @param {*} size
 *  用于记录处理步骤  可以用于需要回退的操作
 */
function RecordOperation(size = 10) {
  // 记录表格的变化用于返回到以前状态
  const records = [];
  // 记录深度
  const recordSize = size;
  // 记录当前显示下标
  let recordIndex = -1;
  this.hasNext = false;
  this.hasBack = false;

  // 插入记录
  function pushRecord(value) {
    if (value) {
      if (records.length < recordSize) {
        if (recordIndex !== records.length - 1) {
          const len = records.length - recordIndex - 1;
          records.splice(-len, len, value);
        } else {
          records.push(value);
        }
      } else {
        records.shift();
        records.push(value);
      }
      recordIndex = records.length - 1;
      this.hasBack = records.length - 1 > 0;
      this.hasNext = false;
    }
  };
  this.pushRecord = pushRecord;
  this.push = pushRecord;
  // 向前获取记录
  this.next = function next() {
    if (recordIndex + 1 < records.length) {
      recordIndex += 1;
      this.hasNext = recordIndex + 1 < records.length;
      this.hasBack = true;
      return records[recordIndex];
    }
    return null;
  };
  // 向后获取记录
  this.back = function back() {
    if (recordIndex - 1 >= 0) {
      recordIndex -= 1;
      this.hasBack = recordIndex - 1 >= 0;
      this.hasNext = true;
      return records[recordIndex];
    }
    return null;
  };
  return this;
}

/**
 * 将rgb字符串转为16进制  rgb(0,0,0) -> #000000
 * @param {*} rgb 
 * @returns 
 */
function rgbToHex(rgb) {
  if (rgb && rgb.indexOf('rgb') == 0) {
    const strs = rgb.substring(rgb.indexOf('(') + 1, rgb.length - 1).split(',');
    const a = strs[0] > 15 ? parseInt(strs[0]).toString(16) : '0'.concat(parseInt(strs[0]).toString(16));
    const b = strs[1] > 15 ? parseInt(strs[1]).toString(16) : '0'.concat(parseInt(strs[1]).toString(16));
    const c = strs[2] > 15 ? parseInt(strs[2]).toString(16) : '0'.concat(parseInt(strs[2]).toString(16));
    return "#".concat(a).concat(b).concat(c);
  } else {
    return rgb;
  }
}

/**
 * 删除数组中的某一项或某一类数据
 * @param {*} arrs 原始数组
 * @param {*} index 删除的下标
 * @param {*} item 删除的值 可以是对象或基础类型，只要是数组当中有的
 * @param {*} key 当传入的是对象时，需要指定比较的字段 相同则删除
 */
function removeItemInArray(arrs, index, item, key) {
  let size = arrs.length - 1;
  let n = index;
  if (index instanceof Number) {
    if (index < size - 1) {
      for (let i = index; i < size; i++) {
        arrs[i] = arrs[i + 1];
      }
    }
    arrs.pop();
  } else if (item instanceof Object && key) {
    let hasNext = false;
    n = size;
    for (let i = 0; i < size; i++) {
      if (!hasNext && arrs[i] instanceof Object && item[key] == arrs[i][key]) {
        hasNext = true;
        n = i;
      }
      if (hasNext) {
        arrs[i] = arrs[i + 1];
      }
    }
    arrs.pop();
  } else if (item) {
    let hasNext = false;
    n = size;
    for (let i = 0; i < size; i++) {
      if (!hasNext && item == arrs[i]) {
        hasNext = true;
        n = i;
      }
      if (hasNext) {
        arrs[i] = arrs[i + 1];
      }
    }
    arrs.pop();
  }
  return n;
}

/**
 * 创建表单
 * @param {*} data 数组 [{name: string; value?: string; placeholder?: string}]
 * @param {*} onChange 
 * @returns 
 */
function createForm(data, onChange) {
  if (data instanceof Array) {
    return gkhCreate('form', {
      className: 'gkh-form',
      childs: data.map(item => gkhCreate('div', {
        childs: [
          gkhCreate('label', { innerText: item.label }),
          gkhCreate('input', { attribute: { value: item.value ? item.value : '', placeholder: item.placeholder, name: item.name }, listeners: { change: onChange } }),
        ]
      }))
    })
  }
  return undefined;
}

/**
 * 样式类名处理函数
 * @param {*} className 原始类名
 * @param {*} name 需要增加或删除的类名
 * @param {*} type 'add' | 'del'  新增还是删除
 */
const classNameDeal = (className, name, type = 'add') => {
  const index = className.indexOf(name);
  if (type == 'add') {
    if (index < 0) {
      if (className.length > 0) {
        className += " ".concat(name);
      } else {
        className += name;
      }
      container.setAttribute('class', className);
    }
  } else if (index > -1) {
    className = className.substring(0, index).concat(className.substring(index + name.length));
    if (className.charAt(0) === ' ') {
      className = className.substring(1);
    }
    if (className.charAt(className.length - 1) === ' ') {
      className = className.substring(0, className.length - 1);
    }
  }
  return className;
}


export {
  gkhCreate, // 创建元素并初始化属性
  RecordOperation, // 用于记录处理步骤  可以用于需要回退的操作
  rgbToHex, // 将rgb字符串转为16进制  rgb(0,0,0) -> #000000
  createForm, // 创建form表单
  removeItemInArray, // 删除数组中的某一项或某一类数据
  classNameDeal,  // 样式类名处理函数
};
